home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / HDF / dfcomp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  15.2 KB  |  517 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.2 $";
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfcomp.c,v 3.2 90/07/02 10:12:14 clow beta $
  27.  
  28. $Log:    dfcomp.c,v $
  29.  * Revision 3.2  90/07/02  10:12:14  clow
  30.  * some cosmetic modifications
  31.  * 
  32. */
  33. /*-----------------------------------------------------------------------------
  34.  * File:    dfcomp.c
  35.  * Purpose: File compression
  36.  * Invokes: df.c dfimcomp.c df.h
  37.  * Contents: 
  38.  *  DFputcomp: compress image and write it to HDF file
  39.  *  DFgetcomp: read compressed image from HDF file and decompress it
  40.  *  DFCrle: compress string using run length encoding
  41.  *  DFCunrle: decompress string using run length encoding
  42.  * Remarks: DFgetcomp and DFputcomp constitute a general compression interface
  43.  *---------------------------------------------------------------------------*/
  44.  
  45. #include "df.h"
  46.  
  47. #ifndef VMS
  48. extern void DFCimcomp(), DFCunimcomp();
  49. #else /*VMS*/
  50. extern void _DFCimcomp(), _DFCunimcomp();
  51. #endif
  52.  
  53. /*-----------------------------------------------------------------------------
  54.  * Name:    DFputcomp
  55.  * Purpose: Compress and write images to HDF file
  56.  * Inputs:  dfile: pointer to HDF file
  57.  *          tag, ref: tag, ref of compressed image for writing out
  58.  *          image: image to be compressed
  59.  *          xdim, ydim: dimensions of image
  60.  *          palette: palette associated with image
  61.  *          newpal: modified palette, produced if compression scheme is IMCOMP
  62.  *          scheme: compression scheme to be used
  63.  * Returns: 0 on success, -1 on failure with DFerror set
  64.  * Users:   HDF programmers, DF8putrig, other routines
  65.  * Invokes: DFCrle, DFCimcomp, DFaccess, DFwrite, DFIcheck
  66.  * Remarks: IMCOMP modifies the palette associated with the image
  67.  *          Hence the palette and newpal arguments
  68.  *          This is a general compression interface - to be used anytime image
  69.  *          compression is needed in HDF
  70.  *          Note that rseq does its own compression, because that is part of
  71.  *          the interactive color raster protocol
  72.  *          The space needed for compression and decompression can be allocated
  73.  *          statically or dynamically, depending on the DF_DYNAMIC flag, and
  74.  *          for entire image or part of it (reused) depending on availability
  75.  *          Accordingly, writing out is whole image, or row by row
  76.  *          Note that compression is always row by row for RLE.
  77.  *---------------------------------------------------------------------------*/
  78.  
  79.  
  80. int DFputcomp(dfile, tag, ref, image, xdim, ydim, palette, newpal, scheme)
  81. DF *dfile;
  82. uint16 tag, ref;
  83. char *image;
  84. int32 xdim, ydim;
  85. char *palette, *newpal;
  86. int16 scheme;
  87. {
  88.     char *buffer;        /* buffer to hold compressed image */
  89.     char *in;            /* pointer to input for compression */
  90.     char *out;            /* pointer to space for compressed output */
  91.     int32 cisize;        /* maximum size of compressed image */
  92.     int32 crowsize;        /* maximum size of compressed row */
  93.     int32 buftype;        /* buftype = 1: buffer enough for whole image*/
  94.                 /* buftype = 2: buffer holds 1 row */
  95.     int32 n;            /* number of compressed bytes produced */
  96.     int32 total;        /* total compressed bytes produced so far */
  97.     int i, ret=0;
  98.  
  99.     if (DFIcheck(dfile)<0) return(-1);
  100.     if (!tag) {
  101.         DFerror = DFE_BADTAG;
  102.         return(-1);
  103.     }
  104.     if (!ref) {
  105.         DFerror = DFE_BADREF;
  106.         return(-1);
  107.     }
  108.     if ((xdim<=0) || (ydim<=0)) {
  109.         DFerror = DFE_BADDIM;
  110.         return(-1);
  111.     }
  112.     if (!image) {
  113.         DFerror = DFE_BADPTR;
  114.         return(-1);
  115.     }
  116.  
  117.     if (DFaccess(dfile, tag, ref, "w")<0) return(-1); /* setup to write CI */
  118.  
  119.     switch (scheme) {
  120.       case DFTAG_RLE:
  121.     cisize = ydim*(xdim*121/120+1);    /* 120 chars can compress to 121! */
  122.     crowsize = xdim*121/120 + 128;
  123.  
  124.     /* allocate buffer for compression */
  125. #ifdef DF_DYNAMIC        /* large mallocs OK */
  126.     buffer = (char *) DFIgetspace((unsigned)cisize);
  127.     if (!buffer) {
  128.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  129.         if (!buffer) {
  130.         DFerror = DFE_NOSPACE;
  131.         return(-1);
  132.         }
  133.         buftype = 2;    /* compress and write out row by row */
  134.     }
  135.     else buftype = 1;       /* can hold whole image, then write */
  136.  
  137. #else /*DF_DYNAMIC                    use static buffers */
  138.     buffer = DFtbuf;
  139.     if (DF_TBUFSZ>=cisize) buftype = 1;
  140.     else if (DF_TBUFSZ>crowsize) buftype = 2;
  141.     else {
  142.         DFerror = DFE_NOSPACE;
  143.         return(-1);
  144.     }
  145. #endif /*DF_DYNAMIC*/
  146.  
  147.     in = image;
  148.     out = buffer;
  149.     n = total = 0;        /* no bytes compressed so far */
  150.  
  151.     /* compress row by row */
  152.     for (i=0; i<ydim; i++) {
  153.         n = DFCrle(in, out, xdim); /* compress row */
  154.         in += xdim;        /* move input pointer */
  155.         total += n;        /* keep running total */
  156.         if (buftype==1)    /* can hold whole image */
  157.         out = &buffer[total]; /* move out buffer pointer */
  158.         else {        /* buffer too small, */
  159.                 /* write out what was produced */
  160.         if (DFwrite(dfile, buffer, n)<0) {
  161.             ret = -1;    /* flag value */
  162.             break;
  163.         }
  164.         out = buffer;    /* reset output pointer */
  165.         }
  166.     }
  167.  
  168.     if (buftype==1)        /* write out entire image */
  169.                 ret = DFwrite(dfile, buffer, total);
  170.     break;
  171.  
  172.       case DFTAG_IMC:
  173.         if (!palette || !newpal) { /* need palette and newpal */
  174.             DFerror = DFE_BADPTR;
  175.             return(-1);
  176.         }
  177.         cisize = xdim*ydim/4;    /* IMCOMP always cuts to 1/4 */
  178.  
  179. #ifdef DF_DYNAMIC
  180.         buffer = (char *) DFIgetspace((unsigned)cisize);
  181.         if (!buffer) {
  182.             DFerror = DFE_NOSPACE;
  183.             return(-1);
  184.         }
  185. #else /*DF_DYNAMIC*/
  186.         if (DF_TBUFSZ<cisize) {
  187.             DFerror = DFE_NOSPACE;
  188.             return(-1);
  189.         }
  190.         buffer = DFtbuf;
  191. #endif /*DF_DYNAMIC*/
  192.  
  193.         DFCimcomp(xdim, ydim, image, buffer, palette, newpal, 0);
  194.         ret = DFwrite(dfile, buffer, cisize);
  195.         break;
  196.  
  197.     default:            /* unknown compression scheme */
  198.         DFerror = DFE_BADSCHEME;
  199.         return(-1);
  200.         break;
  201.     }
  202. #ifdef DF_DYNAMIC
  203.     DFIfreespace((char*)buffer);
  204. #endif /*DF_DYNAMIC*/
  205.     return(ret);
  206. }
  207.  
  208. /*-----------------------------------------------------------------------------
  209.  * Name:    DFgetcomp
  210.  * Purpose: Read compressed image and decompress it
  211.  * Inputs:  dfile: HDF file pointer
  212.  *          tag, ref: id of image to be decompressed
  213.  *          image: space to return decompressed image in
  214.  *          xdim, ydim: dimensions of decompressed image
  215.  *          scheme: compression scheme used
  216.  * Returns: 0 on success, -1 on failure with DFerror set
  217.  * Users:   HDF programmers, DF8getrig, other routines
  218.  * Invokes: DFIcheck, DFIfind, DFaccess, DFread, DFCunrle, DFCunimcomp
  219.  * Remarks: Will use dynamic/static memory allocation for buffer
  220.  *          will read in image in parts if memory insufficient
  221.  *          Decompression of rle is not necessarily row by row
  222.  *          Other encodings can also be decoded with this
  223.  *---------------------------------------------------------------------------*/
  224.  
  225. int DFgetcomp(dfile, tag, ref, image, xdim, ydim, scheme)
  226. DF *dfile;
  227. uint16 tag, ref;
  228. char *image;
  229. int32 xdim, ydim;
  230. uint16 scheme;
  231. {
  232.     char *buffer, *in, *out;
  233.     int32 cisize, crowsize, buflen, bufleft; /* bufleft: bytes left in buffer*/
  234.     DFdle *dlep;
  235.     int cdd, i, n, totalread;
  236.  
  237.     if (DFIcheck(dfile)<0) return(-1);
  238.     if (!tag) {
  239.         DFerror = DFE_BADTAG;
  240.         return(-1);
  241.     }
  242.     if (!ref) {
  243.         DFerror = DFE_BADREF;
  244.         return(-1);
  245.     }
  246.     if (!image) {
  247.         DFerror = DFE_BADPTR;
  248.         return(-1);
  249.     }
  250.     if ((xdim<=0) || (ydim<=0)) {
  251.         DFerror = DFE_BADDIM;
  252.         return(-1);
  253.     }
  254.  
  255.     if (DFIfind(dfile, tag, ref, 1, 0, 0, &dlep, &cdd)<0) {
  256.         DFerror = DFE_NOMATCH;
  257.         return(-1);
  258.     }
  259.     cisize = dlep->dd[cdd].length;
  260.  
  261.     if (DFaccess(dfile, tag, ref, "r")<0) return(-1);
  262.     switch (scheme) {
  263.       case DFTAG_RLE:
  264.     crowsize = xdim*121/120 + 128; /* max size of a row */
  265.  
  266. #ifdef DF_DYNAMIC
  267.     buffer = (char *) DFIgetspace((unsigned)cisize);
  268.     if (!buffer) {
  269.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  270.         if (!buffer) {
  271.         DFerror = DFE_NOSPACE;
  272.         return(-1);
  273.         }
  274.         buflen = crowsize;
  275.     }
  276.     else buflen = cisize;
  277. #else /*DF_DYNAMIC*/
  278.     if (DF_TBUFSZ<crowsize) {
  279.         DFerror = DFE_NOSPACE;
  280.         return(-1);
  281.     }
  282.     buffer = DFtbuf;    /* static compression buffer */
  283.     buflen = DF_TBUFSZ;
  284. #endif /*DF_DYNAMIC*/
  285.  
  286.     in = buffer;
  287.     out = image;
  288.     if ((n=DFread(dfile, in, buflen))<0) {
  289. #ifdef DF_DYNAMIC
  290.         DFIfreespace((char*)buffer);
  291. #endif /*DF_DYNAMIC*/
  292.         return(-1);
  293.     }
  294.     totalread = n;
  295.     bufleft = n;
  296.     for (i=0; i<ydim; i++) {
  297.         n = DFCunrle(in, out, xdim, !i); /* no of bytes used up */
  298.         /* last arg=TRUE if i=0 - resets decompress */
  299.         in += n;
  300.         out += xdim;
  301.         bufleft -= n;
  302.         /* check if more bytes may be needed for next read */
  303.         if ((bufleft<crowsize) && (totalread<cisize)) {
  304.         DFmovmem(in, buffer, (int)bufleft);
  305.         in = buffer;
  306.         if ((n=DFread(dfile,&in[bufleft],buflen-bufleft))<0) {
  307. #ifdef DF_DYNAMIC
  308.             DFIfreespace((char*)buffer);
  309. #endif /*DF_DYNAMIC   */
  310.             return(-1);
  311.         }
  312.         totalread += n;
  313.         bufleft += n;
  314.         }
  315.     }
  316.     break;
  317.  
  318.       case DFTAG_IMC:
  319.     crowsize = xdim;    /* size of compressed row */
  320.  
  321. #ifdef DF_DYNAMIC
  322.     buffer = (char *) DFIgetspace((unsigned)cisize);
  323.     if (!buffer) {
  324.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  325.         if (!buffer) {
  326.         DFerror = DFE_NOSPACE;
  327.         return(-1);
  328.         }
  329.         buflen = crowsize;
  330.     }
  331.     else buflen = cisize;
  332. #else /*DF_DYNAMIC*/
  333.     buffer = DFtbuf;    /* static compression buffer */
  334.     if (DF_TBUFSZ<crowsize) {
  335.         DFerror = DFE_NOSPACE;
  336.         return(-1);
  337.     }
  338.     buflen = DF_TBUFSZ;
  339. #endif /*DF_DYNAMIC*/
  340.     if (buflen>=cisize) {
  341.         if (DFread(dfile, buffer, cisize)<cisize) {
  342. #ifdef DF_DYNAMIC
  343.         DFIfreespace((char*)buffer);
  344. #endif /*DF_DYNAMIC*/
  345.         return(-1);
  346.         }
  347.         DFCunimcomp(xdim, ydim, buffer, image);
  348.         break;        /* go to end of switch */
  349.     }
  350.  
  351.     in = buffer;        /* if can only read piecemeal */
  352.     out = image;
  353.     if ((n=DFread(dfile, in, buflen))<0) {
  354. #ifdef DF_DYNAMIC
  355.         DFIfreespace((char*)buffer);
  356. #endif /*DF_DYNAMIC*/
  357.         return(-1);
  358.     }
  359.     totalread = n;
  360.     bufleft = n;
  361.     for (i=0; i<ydim; i+=4) {
  362.         DFCunimcomp(xdim, (int32)4, in, out);
  363.         in += xdim;
  364.         out += 4*xdim;
  365.         bufleft -= xdim;
  366.         if ((bufleft<crowsize) && (totalread<cisize)) {
  367.         DFmovmem(in, buffer, (int)bufleft);
  368.         in = buffer;
  369.         if ((n=DFread(dfile,&in[bufleft],buflen-bufleft))<0) {
  370. #ifdef DF_DYNAMIC
  371.             DFIfreespace((char*)buffer);
  372. #endif /*DF_DYNAMIC*/
  373.             return(-1);
  374.         }
  375.         totalread += n;
  376.         bufleft += n;
  377.         }
  378.     }
  379.     break;
  380.  
  381.       default:            /* unknown scheme */
  382.     DFerror = DFE_BADSCHEME;
  383.     return(-1);
  384.     break;
  385.     }
  386. #ifdef DF_DYNAMIC
  387.     DFIfreespace((char*)buffer);
  388. #endif /*DF_DYNAMIC*/
  389.     return(0);
  390. }
  391.  
  392. /*-----------------------------------------------------------------------------
  393.  * Name:    DFCrle
  394.  * Purpose: compress a string of bytes
  395.  * Inputs:  buf: buffer containing data to be compressed
  396.  *          bufto: space for compressed data - assumed big enough
  397.  *          len: number of bytes to compress
  398.  * Returns: number of compressed bytes on success, -1 on failure
  399.  * Users:   HDF programmers, DFputcomp, other routines
  400.  * Invokes: none
  401.  * Remarks: Written for efficiency
  402.  *---------------------------------------------------------------------------*/
  403.  
  404. int DFCrle(buf,bufto,len)
  405. int32 len;
  406. char *buf,*bufto;
  407. {
  408.     register char *p,*q,*cfoll,*clead;
  409.     char *begp;
  410.     int32 i;
  411.  
  412.     p = buf;
  413.     cfoll = bufto;        /* place to copy to */
  414.     clead = cfoll + 1;
  415.     
  416.     begp = p;
  417.     while (len > 0) {           /* encode stuff until gone */
  418.  
  419.         q = p + 1;
  420.         i = len-1;
  421.         while (i && i+120 > len && *p == *q) {
  422.             q++;
  423.             i--;
  424.         }
  425.         
  426.         if (q > p + 2) {        /* three in a row */
  427.             if (p > begp) {
  428.                 *cfoll = p - begp;
  429.                 cfoll = clead;
  430.             }
  431.             *cfoll++ = 128 | (q-p); /* len of seq */
  432.             *cfoll++ = *p;      /* char of seq */
  433.             len -= q-p;         /* subtract len of seq */
  434.             p = q;
  435.             clead = cfoll+1;
  436.             begp = p;
  437.         }
  438.         else {
  439.             *clead++ = *p++;    /* copy one char */
  440.             len--;
  441.             if (p > begp + 120) {
  442.                 *cfoll = p - begp;
  443.                 cfoll = clead++;
  444.                 begp = p;
  445.             }
  446.         }
  447.         
  448.     }
  449. /*
  450.  *  fill in last bytecount
  451.  */
  452.     if (p > begp) 
  453.         *cfoll = (p - begp);
  454.     else
  455.         clead--;                    /* don't need count position */
  456.     
  457.     return((int)(clead - bufto));   /* how many stored as encoded */
  458. }
  459.  
  460. /*-----------------------------------------------------------------------------
  461.  * Name:    DFCunrle
  462.  * Purpose: decompress run length encoding
  463.  * Inputs:  buf: buffer containing compressed data
  464.  *          bufto: space for returning decompressed data
  465.  *          outlen: number of *decompressed* bytes desired.
  466.  *          resetsave: don't use any stored state info - used for fresh image
  467.  * Returns: number of compressed bytes used up on success, -1 on failure
  468.  * Users:   HDF programmers, DFgetcomp, other routines
  469.  * Invokes: none
  470.  * Remarks: has been modified so it will decompress even non-rowwise compression
  471.  *          Hence the static storage stuff
  472.  *---------------------------------------------------------------------------*/
  473.  
  474. int DFCunrle(buf,bufto,outlen, resetsave)
  475. int32 outlen;
  476. char *buf,*bufto;
  477. int resetsave;
  478. {
  479.     register int cnt;
  480.     register char *p,*q;
  481.     char *endp;
  482.     static char save[255], *savestart=NULL, *saveend=NULL;
  483.     /* save has a list of decompressed bytes not returned in
  484.        previous call.  savestart and saveend specify the position
  485.        at which this list starts and ends in the array save */
  486.     
  487.     p = buf;
  488.     endp = bufto + outlen;
  489.     q = bufto;
  490.     if (resetsave) savestart = saveend = save; /* forget saved state */
  491.     while ((saveend>savestart) && (q<endp)) /* copy saved stuff */
  492.         *q++ = *savestart++;
  493.     if (savestart>=saveend) savestart = saveend = save;    /* all copied */
  494.     while (q < endp) {
  495.         cnt = *p++;        /* count field */
  496.         if (!(cnt & 128)) {    /* is set of uniques */
  497.             while (cnt--) {
  498.                 if (q<endp)
  499.                     *q++ = *p++; /* copy unmodified */
  500.                 else
  501.                     *saveend++ = *p++;
  502.             }
  503.         }
  504.         else {
  505.             cnt &= 127;        /* strip high bit */
  506.             while (cnt--) {
  507.                 if (q<endp)
  508.                     *q++ = *p;  /* copy unmodified */
  509.                 else
  510.                     *saveend++ = *p;
  511.             }
  512.             p++;                /* skip that character */
  513.         }
  514.     }
  515.     return((int)(p-buf));
  516. }
  517.